#include "ConcurrentAlloc.h"
#include<Windows.h>
#include<iostream>


#include<vector>
#include<atomic>

// ntimes 一轮申请和释放内存的次数
// rounds 轮次
// void BenchmarkMalloc(size_t ntimes, size_t nworks, size_t rounds)
// {
// 	std::vector<std::thread> vthread(nworks);
// 	std::atomic<size_t> malloc_costtime(0);
// 	std::atomic<size_t> free_costtime(0);

// 	for (size_t k = 0; k < nworks; ++k)
// 	{
// 		vthread[k] = std::thread([&, k]() {
// 			std::vector<void*> v;
// 			v.reserve(ntimes);

// 			for (size_t j = 0; j < rounds; ++j)
// 			{
// 				size_t begin1 = clock();
// 				for (size_t i = 0; i < ntimes; i++)
// 				{
// 					// v.push_back(malloc(16));
// 					v.push_back(malloc((16 + i) % 8192 + 1));
// 				}
// 				size_t end1 = clock();

// 				size_t begin2 = clock();
// 				for (size_t i = 0; i < ntimes; i++)
// 				{
// 					free(v[i]);
// 				}
// 				size_t end2 = clock();
// 				v.clear();

// 				malloc_costtime += (end1 - begin1);
// 				free_costtime += (end2 - begin2);
// 			}
// 		});
// 	}

// 	for (auto& t : vthread)
// 	{
// 		t.join();
// 	}

// 	printf("%u个线程并发执行%u轮次,每轮次malloc %u次:",
// 		nworks, rounds, ntimes);
//         std::cout <<  "花费:" <<malloc_costtime << std::endl;

// 	printf("%u个线程并发执行%u轮次,每轮次free %u次:",
// 		nworks, rounds, ntimes);
//         std::cout <<  "花费:" <<free_costtime << std::endl;


// 	printf("%u个线程并发malloc&free %u次,总计花费：%u ms\n",
// 		nworks, nworks*rounds*ntimes, malloc_costtime + free_costtime);
// }


// // 单轮次申请释放次数 线程数 轮次
// void BenchmarkConcurrentMalloc(size_t ntimes, size_t nworks, size_t rounds)
// {
// 	std::vector<std::thread> vthread(nworks);
// 	std::atomic<size_t> malloc_costtime(0);
// 	std::atomic<size_t> free_costtime(0);

// 	for (size_t k = 0; k < nworks; ++k)
// 	{
// 		vthread[k] = std::thread([&]() {
// 			std::vector<void*> v;
// 			v.reserve(ntimes);

// 			for (size_t j = 0; j < rounds; ++j)
// 			{
// 				size_t begin1 = clock();
// 				for (size_t i = 0; i < ntimes; i++)
// 				{
// 					// v.push_back(ConcurrentAlloc(16));
// 					v.push_back(ConcurrentAlloc((16 + i) % 8192 + 1));
// 				}
// 				size_t end1 = clock();

// 				size_t begin2 = clock();
// 				for (size_t i = 0; i < ntimes; i++)
// 				{
// 					ConcurrentDelloc(v[i]);
// 				}
// 				size_t end2 = clock();
// 				v.clear();

// 				malloc_costtime += (end1 - begin1);
// 				free_costtime += (end2 - begin2);
// 			}
// 		});
// 	}

// 	for (auto& t : vthread)
// 	{
// 		t.join();
// 	}

// 	printf("%u个线程并发执行%u轮次,每轮次malloc %u次:",
// 		nworks, rounds, ntimes);
//         std::cout <<  "花费:" <<malloc_costtime << std::endl;

// 	printf("%u个线程并发执行%u轮次,每轮次free %u次:",
// 		nworks, rounds, ntimes);
//         std::cout <<  "花费:" <<free_costtime << std::endl;

// 	printf("%u个线程并发concurrent alloc&dealloc %u次,总计花费：%u ms\n",
// 		nworks, nworks*rounds*ntimes, malloc_costtime + free_costtime);
// }

// int main()
// {
// 	size_t n = 200;
// 	cout << "==========================================================" << endl;
// 	BenchmarkConcurrentMalloc(n, 4, 1024);
// 	cout << endl << endl;

// 	BenchmarkMalloc(n, 4, 1024);
// 	cout << "==========================================================" << endl;

// 	return 0;
// }












void foo()
{
    // int *ptr[1024*10];
    // for (int i = 0; i < 1024*10 ; i++)
    // {
    //     ptr[i] = (int *)ConcurrentAlloc(i+1);
    //     *(ptr[i]) = i;
    //     // cout << *(ptr[i]) <<  " ";
    // }
    // for (int i = 0; i < 1024*100 ; i++)
    // {
    //     ConcurrentDelloc(ptr[i],i+1);
    // }

	std::vector<int*> v;
	std::vector<int*> v2;
	const int num = 10;
	v.reserve(num);
	v2.reserve(num);

    for (int i = 0; i < num ; i++)
    {

        v[i] = (int*)ConcurrentAlloc((256+i+1)*1024);
        v2[i] = (int*)ConcurrentAlloc((NPAGES+i) << ShiftPageSize);
        // v2[i] = (int*)ConcurrentAlloc(rand()%(256*1024)+1);
        // cout << *(ptr[i]) <<  " ";
    }

    for (int i = 0; i < num ; i++)
    {
        ConcurrentDelloc(v[i]);
        ConcurrentDelloc(v2[i]);

    }
}
int main()
{
	srand((unsigned int)time(nullptr));
    std::thread a1(foo);
    std::thread a2(foo);
    std::thread a3(foo);
    std::thread a4(foo);
    std::thread a5(foo);
    std::thread a6(foo);
    std::thread a7(foo);
    std::thread a8(foo);


    a1.join();
    a2.join();
    a3.join();
    a4.join();
    a5.join();
    a6.join();
    a7.join();
    a8.join();

    printf("结束\n");

    return 0;
}


















// #include <iostream>
// #include<thread>
// #include<mutex>

// class X{
//     public:
//     int data = 0;
// };

// static __thread X* x;

// static std::mutex mtx;
// void foo()
// {
//     x = new X();
//     // void* ptr = ConcurrentAlloc(10);
//     if(x == nullptr)
//     {
//         std::cout << "nullptr" << std::endl;
//         x = new X();
//     }
//     mtx.lock();
//     std::cout << ++(x->data) << std::endl;
//     mtx.unlock();
// }
// int main()
// {
//     std::thread a1(foo);
//     std::thread a2(foo);
//     std::thread a3(foo);
//     std::thread a4(foo);

//     a1.join();
//     a2.join();
//     a3.join();
//     a4.join();

//     return 0;
// }